/**
 *
 */
import Util;
import OpenApi;
import OpenApiUtil;
import EndpointUtil;

extends OpenApi;


init(config: OpenApi.Config){
  super(config);
  @endpointRule = '';
  
  checkConfig(config);
  @endpoint = getEndpoint('umeng-finplus', @regionId, @endpointRule, @network, @suffix, @endpointMap, @endpoint);
}

function getEndpoint(productId: string, regionId: string, endpointRule: string, network: string, suffix: string, endpointMap: map[string]string, endpoint: string) throws: string{
  if (!Util.empty(endpoint)) {
    return endpoint;
  }
  
  if (!Util.isUnset(endpointMap) && !Util.empty(endpointMap[regionId])) {
    return endpointMap[regionId];
  }
  return EndpointUtil.getEndpointRules(productId, regionId, endpointRule, network, suffix);
}

model BuildStsAKRequest {
  body?: long(name='body'),
}

model BuildStsAKResponseBody = {
  code?: string(name='Code'),
  data?: {
    bucket?: string(name='bucket'),
    endpoint?: string(name='endpoint'),
    id?: string(name='id'),
    path?: string(name='path'),
    secret?: string(name='secret'),
    token?: string(name='token'),
  }(name='Data'),
  msg?: string(name='Msg'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model BuildStsAKResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: BuildStsAKResponseBody(name='body'),
}

/**
 * @summary 提交数据集任务，校验数据集
 *
 * @param request BuildStsAKRequest
 * @param headers map
 * @param runtime runtime options for this request RuntimeOptions
 * @return BuildStsAKResponse
 */
async function buildStsAKWithOptions(request: BuildStsAKRequest, headers: map[string]string, runtime: Util.RuntimeOptions): BuildStsAKResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    headers = headers,
    body = request.body,
  };
  var params = new OpenApi.Params{
    action = 'BuildStsAK',
    version = '2022-09-13',
    protocol = 'HTTPS',
    pathname = `/bc/buildStsAK`,
    method = 'POST',
    authType = 'AK',
    style = 'ROA',
    reqBodyType = 'json',
    bodyType = 'json',
  };
  if (Util.isUnset(@signatureVersion) || !Util.equalString(@signatureVersion, 'v4')) {
    return callApi(params, req, runtime);
  } else {
    return execute(params, req, runtime);
  }
}

/**
 * @summary 提交数据集任务，校验数据集
 *
 * @param request BuildStsAKRequest
 * @return BuildStsAKResponse
 */
async function buildStsAK(request: BuildStsAKRequest): BuildStsAKResponse {
  var runtime = new Util.RuntimeOptions{};
  var headers : map[string]string = {};
  return buildStsAKWithOptions(request, headers, runtime);
}

model BuildStsAK2Request {
  clientId?: long(name='clientId'),
  dataSetId?: long(name='dataSetId'),
}

model BuildStsAK2ResponseBody = {
  code?: string(name='Code'),
  data?: {
    bucket?: string(name='bucket'),
    endpoint?: string(name='endpoint'),
    id?: string(name='id'),
    path?: string(name='path'),
    secret?: string(name='secret'),
    token?: string(name='token'),
  }(name='Data'),
  msg?: string(name='Msg'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model BuildStsAK2Response = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: BuildStsAK2ResponseBody(name='body'),
}

/**
 * @summary 提交数据集任务，校验数据集
 *
 * @param request BuildStsAK2Request
 * @param headers map
 * @param runtime runtime options for this request RuntimeOptions
 * @return BuildStsAK2Response
 */
async function buildStsAK2WithOptions(request: BuildStsAK2Request, headers: map[string]string, runtime: Util.RuntimeOptions): BuildStsAK2Response {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.clientId)) {
    body['clientId'] = request.clientId;
  }
  if (!Util.isUnset(request.dataSetId)) {
    body['dataSetId'] = request.dataSetId;
  }

  var req = new OpenApi.OpenApiRequest{ 
    headers = headers,
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'BuildStsAK2',
    version = '2022-09-13',
    protocol = 'HTTPS',
    pathname = `/bc/buildStsAK2`,
    method = 'POST',
    authType = 'AK',
    style = 'ROA',
    reqBodyType = 'json',
    bodyType = 'json',
  };
  if (Util.isUnset(@signatureVersion) || !Util.equalString(@signatureVersion, 'v4')) {
    return callApi(params, req, runtime);
  } else {
    return execute(params, req, runtime);
  }
}

/**
 * @summary 提交数据集任务，校验数据集
 *
 * @param request BuildStsAK2Request
 * @return BuildStsAK2Response
 */
async function buildStsAK2(request: BuildStsAK2Request): BuildStsAK2Response {
  var runtime = new Util.RuntimeOptions{};
  var headers : map[string]string = {};
  return buildStsAK2WithOptions(request, headers, runtime);
}

model CancelTaskRequest {
  body?: long(name='body'),
}

model CancelTaskResponseBody = {
  code?: string(name='Code'),
  data?: boolean(name='Data'),
  msg?: string(name='Msg'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model CancelTaskResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: CancelTaskResponseBody(name='body'),
}

/**
 * @summary 取消批量计算任务
 *
 * @param request CancelTaskRequest
 * @param headers map
 * @param runtime runtime options for this request RuntimeOptions
 * @return CancelTaskResponse
 */
async function cancelTaskWithOptions(request: CancelTaskRequest, headers: map[string]string, runtime: Util.RuntimeOptions): CancelTaskResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    headers = headers,
    body = request.body,
  };
  var params = new OpenApi.Params{
    action = 'CancelTask',
    version = '2022-09-13',
    protocol = 'HTTPS',
    pathname = `/bc/cancelTask`,
    method = 'POST',
    authType = 'AK',
    style = 'ROA',
    reqBodyType = 'json',
    bodyType = 'json',
  };
  if (Util.isUnset(@signatureVersion) || !Util.equalString(@signatureVersion, 'v4')) {
    return callApi(params, req, runtime);
  } else {
    return execute(params, req, runtime);
  }
}

/**
 * @summary 取消批量计算任务
 *
 * @param request CancelTaskRequest
 * @return CancelTaskResponse
 */
async function cancelTask(request: CancelTaskRequest): CancelTaskResponse {
  var runtime = new Util.RuntimeOptions{};
  var headers : map[string]string = {};
  return cancelTaskWithOptions(request, headers, runtime);
}

model CancelTask2Request {
  bcId?: long(name='bcId'),
  clientId?: long(name='clientId'),
}

model CancelTask2ResponseBody = {
  code?: string(name='Code'),
  data?: boolean(name='Data'),
  msg?: string(name='Msg'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model CancelTask2Response = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: CancelTask2ResponseBody(name='body'),
}

/**
 * @summary 取消批量计算任务
 *
 * @param request CancelTask2Request
 * @param headers map
 * @param runtime runtime options for this request RuntimeOptions
 * @return CancelTask2Response
 */
async function cancelTask2WithOptions(request: CancelTask2Request, headers: map[string]string, runtime: Util.RuntimeOptions): CancelTask2Response {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.bcId)) {
    body['bcId'] = request.bcId;
  }
  if (!Util.isUnset(request.clientId)) {
    body['clientId'] = request.clientId;
  }

  var req = new OpenApi.OpenApiRequest{ 
    headers = headers,
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'CancelTask2',
    version = '2022-09-13',
    protocol = 'HTTPS',
    pathname = `/bc/cancelTask2`,
    method = 'POST',
    authType = 'AK',
    style = 'ROA',
    reqBodyType = 'json',
    bodyType = 'json',
  };
  if (Util.isUnset(@signatureVersion) || !Util.equalString(@signatureVersion, 'v4')) {
    return callApi(params, req, runtime);
  } else {
    return execute(params, req, runtime);
  }
}

/**
 * @summary 取消批量计算任务
 *
 * @param request CancelTask2Request
 * @return CancelTask2Response
 */
async function cancelTask2(request: CancelTask2Request): CancelTask2Response {
  var runtime = new Util.RuntimeOptions{};
  var headers : map[string]string = {};
  return cancelTask2WithOptions(request, headers, runtime);
}

model CreateComputeTaskRequest {
  appId?: long(name='appId'),
  dataSetIds?: string(name='dataSetIds'),
  morseInfoList?: [ 
    {
      cuId?: string(name='cuId'),
      cuVersion?: string(name='cuVersion'),
    }
  ](name='morseInfoList'),
  name?: string(name='name'),
  remarks?: string(name='remarks'),
  type?: string(name='type'),
}

model CreateComputeTaskResponseBody = {
  code?: string(name='Code'),
  data?: long(name='Data'),
  msg?: string(name='Msg'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model CreateComputeTaskResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: CreateComputeTaskResponseBody(name='body'),
}

/**
 * @summary 创建批量计算任务
 *
 * @param request CreateComputeTaskRequest
 * @param headers map
 * @param runtime runtime options for this request RuntimeOptions
 * @return CreateComputeTaskResponse
 */
async function createComputeTaskWithOptions(request: CreateComputeTaskRequest, headers: map[string]string, runtime: Util.RuntimeOptions): CreateComputeTaskResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.appId)) {
    body['appId'] = request.appId;
  }
  if (!Util.isUnset(request.dataSetIds)) {
    body['dataSetIds'] = request.dataSetIds;
  }
  if (!Util.isUnset(request.morseInfoList)) {
    body['morseInfoList'] = request.morseInfoList;
  }
  if (!Util.isUnset(request.name)) {
    body['name'] = request.name;
  }
  if (!Util.isUnset(request.remarks)) {
    body['remarks'] = request.remarks;
  }
  if (!Util.isUnset(request.type)) {
    body['type'] = request.type;
  }

  var req = new OpenApi.OpenApiRequest{ 
    headers = headers,
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'CreateComputeTask',
    version = '2022-09-13',
    protocol = 'HTTPS',
    pathname = `/bc/createComputeTask`,
    method = 'POST',
    authType = 'AK',
    style = 'ROA',
    reqBodyType = 'json',
    bodyType = 'json',
  };
  if (Util.isUnset(@signatureVersion) || !Util.equalString(@signatureVersion, 'v4')) {
    return callApi(params, req, runtime);
  } else {
    return execute(params, req, runtime);
  }
}

/**
 * @summary 创建批量计算任务
 *
 * @param request CreateComputeTaskRequest
 * @return CreateComputeTaskResponse
 */
async function createComputeTask(request: CreateComputeTaskRequest): CreateComputeTaskResponse {
  var runtime = new Util.RuntimeOptions{};
  var headers : map[string]string = {};
  return createComputeTaskWithOptions(request, headers, runtime);
}

model CreateComputeTask2Request {
  appId?: long(name='appId'),
  clientId?: long(name='clientId'),
  dataSetIds?: string(name='dataSetIds'),
  morseInfoList?: [ 
    {
      cuId?: string(name='cuId'),
      cuVersion?: string(name='cuVersion'),
    }
  ](name='morseInfoList'),
  name?: string(name='name'),
  remarks?: string(name='remarks'),
  taskSource?: string(name='taskSource'),
  type?: string(name='type'),
}

model CreateComputeTask2ResponseBody = {
  code?: string(name='Code'),
  data?: long(name='Data'),
  msg?: string(name='Msg'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model CreateComputeTask2Response = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: CreateComputeTask2ResponseBody(name='body'),
}

/**
 * @summary 创建批量计算任务
 *
 * @param request CreateComputeTask2Request
 * @param headers map
 * @param runtime runtime options for this request RuntimeOptions
 * @return CreateComputeTask2Response
 */
async function createComputeTask2WithOptions(request: CreateComputeTask2Request, headers: map[string]string, runtime: Util.RuntimeOptions): CreateComputeTask2Response {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.appId)) {
    body['appId'] = request.appId;
  }
  if (!Util.isUnset(request.clientId)) {
    body['clientId'] = request.clientId;
  }
  if (!Util.isUnset(request.dataSetIds)) {
    body['dataSetIds'] = request.dataSetIds;
  }
  if (!Util.isUnset(request.morseInfoList)) {
    body['morseInfoList'] = request.morseInfoList;
  }
  if (!Util.isUnset(request.name)) {
    body['name'] = request.name;
  }
  if (!Util.isUnset(request.remarks)) {
    body['remarks'] = request.remarks;
  }
  if (!Util.isUnset(request.taskSource)) {
    body['taskSource'] = request.taskSource;
  }
  if (!Util.isUnset(request.type)) {
    body['type'] = request.type;
  }

  var req = new OpenApi.OpenApiRequest{ 
    headers = headers,
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'CreateComputeTask2',
    version = '2022-09-13',
    protocol = 'HTTPS',
    pathname = `/bc/createComputeTask2`,
    method = 'POST',
    authType = 'AK',
    style = 'ROA',
    reqBodyType = 'json',
    bodyType = 'json',
  };
  if (Util.isUnset(@signatureVersion) || !Util.equalString(@signatureVersion, 'v4')) {
    return callApi(params, req, runtime);
  } else {
    return execute(params, req, runtime);
  }
}

/**
 * @summary 创建批量计算任务
 *
 * @param request CreateComputeTask2Request
 * @return CreateComputeTask2Response
 */
async function createComputeTask2(request: CreateComputeTask2Request): CreateComputeTask2Response {
  var runtime = new Util.RuntimeOptions{};
  var headers : map[string]string = {};
  return createComputeTask2WithOptions(request, headers, runtime);
}

model CreateDataSetRequest {
  name?: string(name='name'),
  type?: string(name='type'),
}

model CreateDataSetResponseBody = {
  code?: string(name='Code'),
  data?: long(name='Data'),
  msg?: string(name='Msg'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model CreateDataSetResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: CreateDataSetResponseBody(name='body'),
}

/**
 * @summary 创建数据集
 *
 * @param request CreateDataSetRequest
 * @param headers map
 * @param runtime runtime options for this request RuntimeOptions
 * @return CreateDataSetResponse
 */
async function createDataSetWithOptions(request: CreateDataSetRequest, headers: map[string]string, runtime: Util.RuntimeOptions): CreateDataSetResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.name)) {
    body['name'] = request.name;
  }
  if (!Util.isUnset(request.type)) {
    body['type'] = request.type;
  }

  var req = new OpenApi.OpenApiRequest{ 
    headers = headers,
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'CreateDataSet',
    version = '2022-09-13',
    protocol = 'HTTPS',
    pathname = `/bc/createDataSet`,
    method = 'POST',
    authType = 'AK',
    style = 'ROA',
    reqBodyType = 'json',
    bodyType = 'json',
  };
  if (Util.isUnset(@signatureVersion) || !Util.equalString(@signatureVersion, 'v4')) {
    return callApi(params, req, runtime);
  } else {
    return execute(params, req, runtime);
  }
}

/**
 * @summary 创建数据集
 *
 * @param request CreateDataSetRequest
 * @return CreateDataSetResponse
 */
async function createDataSet(request: CreateDataSetRequest): CreateDataSetResponse {
  var runtime = new Util.RuntimeOptions{};
  var headers : map[string]string = {};
  return createDataSetWithOptions(request, headers, runtime);
}

model CreateDataSet2Request {
  clientId?: long(name='clientId'),
  name?: string(name='name'),
  type?: string(name='type'),
}

model CreateDataSet2ResponseBody = {
  code?: string(name='Code'),
  data?: long(name='Data'),
  msg?: string(name='Msg'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model CreateDataSet2Response = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: CreateDataSet2ResponseBody(name='body'),
}

/**
 * @summary 创建数据集
 *
 * @param request CreateDataSet2Request
 * @param headers map
 * @param runtime runtime options for this request RuntimeOptions
 * @return CreateDataSet2Response
 */
async function createDataSet2WithOptions(request: CreateDataSet2Request, headers: map[string]string, runtime: Util.RuntimeOptions): CreateDataSet2Response {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.clientId)) {
    body['clientId'] = request.clientId;
  }
  if (!Util.isUnset(request.name)) {
    body['name'] = request.name;
  }
  if (!Util.isUnset(request.type)) {
    body['type'] = request.type;
  }

  var req = new OpenApi.OpenApiRequest{ 
    headers = headers,
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'CreateDataSet2',
    version = '2022-09-13',
    protocol = 'HTTPS',
    pathname = `/bc/createDataSet2`,
    method = 'POST',
    authType = 'AK',
    style = 'ROA',
    reqBodyType = 'json',
    bodyType = 'json',
  };
  if (Util.isUnset(@signatureVersion) || !Util.equalString(@signatureVersion, 'v4')) {
    return callApi(params, req, runtime);
  } else {
    return execute(params, req, runtime);
  }
}

/**
 * @summary 创建数据集
 *
 * @param request CreateDataSet2Request
 * @return CreateDataSet2Response
 */
async function createDataSet2(request: CreateDataSet2Request): CreateDataSet2Response {
  var runtime = new Util.RuntimeOptions{};
  var headers : map[string]string = {};
  return createDataSet2WithOptions(request, headers, runtime);
}

model EncryptInvokeRequest {
  clientId?: long(name='clientId'),
  data?: string(name='data'),
  encryptKey?: string(name='encryptKey'),
  methodName?: string(name='methodName'),
  sign?: string(name='sign'),
}

model EncryptInvokeResponseBody = {
  code?: string(name='Code'),
  data?: {
    encryptData?: string(name='encryptData'),
    encryptKey?: string(name='encryptKey'),
    sign?: string(name='sign'),
  }(name='Data'),
  msg?: string(name='Msg'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model EncryptInvokeResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: EncryptInvokeResponseBody(name='body'),
}

/**
 * @summary 加密调用OpenAPI
 *
 * @param request EncryptInvokeRequest
 * @param headers map
 * @param runtime runtime options for this request RuntimeOptions
 * @return EncryptInvokeResponse
 */
async function encryptInvokeWithOptions(request: EncryptInvokeRequest, headers: map[string]string, runtime: Util.RuntimeOptions): EncryptInvokeResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.clientId)) {
    body['clientId'] = request.clientId;
  }
  if (!Util.isUnset(request.data)) {
    body['data'] = request.data;
  }
  if (!Util.isUnset(request.encryptKey)) {
    body['encryptKey'] = request.encryptKey;
  }
  if (!Util.isUnset(request.methodName)) {
    body['methodName'] = request.methodName;
  }
  if (!Util.isUnset(request.sign)) {
    body['sign'] = request.sign;
  }

  var req = new OpenApi.OpenApiRequest{ 
    headers = headers,
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'EncryptInvoke',
    version = '2022-09-13',
    protocol = 'HTTPS',
    pathname = `/bc/encryptInvoke`,
    method = 'POST',
    authType = 'AK',
    style = 'ROA',
    reqBodyType = 'json',
    bodyType = 'json',
  };
  if (Util.isUnset(@signatureVersion) || !Util.equalString(@signatureVersion, 'v4')) {
    return callApi(params, req, runtime);
  } else {
    return execute(params, req, runtime);
  }
}

/**
 * @summary 加密调用OpenAPI
 *
 * @param request EncryptInvokeRequest
 * @return EncryptInvokeResponse
 */
async function encryptInvoke(request: EncryptInvokeRequest): EncryptInvokeResponse {
  var runtime = new Util.RuntimeOptions{};
  var headers : map[string]string = {};
  return encryptInvokeWithOptions(request, headers, runtime);
}

model ListComputeTaskResponseBody = {
  code?: string(name='Code'),
  data?: [ 
    {
      appId?: long(name='appId'),
      bcId?: long(name='bcId'),
      computeOssFileTitle?: string(name='computeOssFileTitle'),
      datasetIds?: string(name='datasetIds'),
      extInfo?: string(name='extInfo'),
      fileNum?: long(name='fileNum'),
      name?: string(name='name'),
      remarks?: string(name='remarks'),
      status?: string(name='status'),
      taskResultList?: [ 
        {
          bcId?: long(name='bcId'),
          code?: int32(name='code'),
          lineNum?: long(name='lineNum'),
        }
      ](name='taskResultList'),
    }
  ](name='Data'),
  msg?: string(name='Msg'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model ListComputeTaskResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: ListComputeTaskResponseBody(name='body'),
}

/**
 * @summary 查询单个批量任务
 *
 * @param headers map
 * @param runtime runtime options for this request RuntimeOptions
 * @return ListComputeTaskResponse
 */
async function listComputeTaskWithOptions(headers: map[string]string, runtime: Util.RuntimeOptions): ListComputeTaskResponse {
  var req = new OpenApi.OpenApiRequest{ 
    headers = headers,
  };
  var params = new OpenApi.Params{
    action = 'ListComputeTask',
    version = '2022-09-13',
    protocol = 'HTTPS',
    pathname = `/bc/listComputeTask`,
    method = 'POST',
    authType = 'AK',
    style = 'ROA',
    reqBodyType = 'json',
    bodyType = 'json',
  };
  if (Util.isUnset(@signatureVersion) || !Util.equalString(@signatureVersion, 'v4')) {
    return callApi(params, req, runtime);
  } else {
    return execute(params, req, runtime);
  }
}

/**
 * @summary 查询单个批量任务
 *
 * @return ListComputeTaskResponse
 */
async function listComputeTask(): ListComputeTaskResponse {
  var runtime = new Util.RuntimeOptions{};
  var headers : map[string]string = {};
  return listComputeTaskWithOptions(headers, runtime);
}

model ListComputeTask2Request {
  clientId?: long(name='clientId'),
  pageNum?: int32(name='pageNum'),
  pageSize?: int32(name='pageSize'),
}

model ListComputeTask2ResponseBody = {
  code?: string(name='Code'),
  data?: {
    data?: [ 
      {
        appId?: long(name='appId'),
        bcId?: long(name='bcId'),
        computeOssFileTitle?: string(name='computeOssFileTitle'),
        datasetIds?: string(name='datasetIds'),
        extInfo?: string(name='extInfo'),
        fileNum?: long(name='fileNum'),
        name?: string(name='name'),
        remarks?: string(name='remarks'),
        status?: string(name='status'),
        taskResultList?: [ 
          {
            bcId?: long(name='bcId'),
            code?: int32(name='code'),
            lineNum?: long(name='lineNum'),
          }
        ](name='taskResultList'),
      }
    ](name='data'),
    totalNum?: int32(name='totalNum'),
  }(name='Data'),
  msg?: string(name='Msg'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model ListComputeTask2Response = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: ListComputeTask2ResponseBody(name='body'),
}

/**
 * @summary 查询单个批量任务
 *
 * @param request ListComputeTask2Request
 * @param headers map
 * @param runtime runtime options for this request RuntimeOptions
 * @return ListComputeTask2Response
 */
async function listComputeTask2WithOptions(request: ListComputeTask2Request, headers: map[string]string, runtime: Util.RuntimeOptions): ListComputeTask2Response {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.clientId)) {
    body['clientId'] = request.clientId;
  }
  if (!Util.isUnset(request.pageNum)) {
    body['pageNum'] = request.pageNum;
  }
  if (!Util.isUnset(request.pageSize)) {
    body['pageSize'] = request.pageSize;
  }

  var req = new OpenApi.OpenApiRequest{ 
    headers = headers,
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'ListComputeTask2',
    version = '2022-09-13',
    protocol = 'HTTPS',
    pathname = `/bc/listComputeTask2`,
    method = 'POST',
    authType = 'AK',
    style = 'ROA',
    reqBodyType = 'json',
    bodyType = 'json',
  };
  if (Util.isUnset(@signatureVersion) || !Util.equalString(@signatureVersion, 'v4')) {
    return callApi(params, req, runtime);
  } else {
    return execute(params, req, runtime);
  }
}

/**
 * @summary 查询单个批量任务
 *
 * @param request ListComputeTask2Request
 * @return ListComputeTask2Response
 */
async function listComputeTask2(request: ListComputeTask2Request): ListComputeTask2Response {
  var runtime = new Util.RuntimeOptions{};
  var headers : map[string]string = {};
  return listComputeTask2WithOptions(request, headers, runtime);
}

model ListDataSetResponseBody = {
  code?: string(name='Code'),
  data?: [ 
    {
      createTime?: string(name='createTime'),
      datasetId?: long(name='datasetId'),
      lineNum?: long(name='lineNum'),
      name?: string(name='name'),
      status?: string(name='status'),
      type?: string(name='type'),
    }
  ](name='Data'),
  msg?: string(name='Msg'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model ListDataSetResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: ListDataSetResponseBody(name='body'),
}

/**
 * @summary 查询单个数据集
 *
 * @param headers map
 * @param runtime runtime options for this request RuntimeOptions
 * @return ListDataSetResponse
 */
async function listDataSetWithOptions(headers: map[string]string, runtime: Util.RuntimeOptions): ListDataSetResponse {
  var req = new OpenApi.OpenApiRequest{ 
    headers = headers,
  };
  var params = new OpenApi.Params{
    action = 'ListDataSet',
    version = '2022-09-13',
    protocol = 'HTTPS',
    pathname = `/bc/listDataSet`,
    method = 'POST',
    authType = 'AK',
    style = 'ROA',
    reqBodyType = 'json',
    bodyType = 'json',
  };
  if (Util.isUnset(@signatureVersion) || !Util.equalString(@signatureVersion, 'v4')) {
    return callApi(params, req, runtime);
  } else {
    return execute(params, req, runtime);
  }
}

/**
 * @summary 查询单个数据集
 *
 * @return ListDataSetResponse
 */
async function listDataSet(): ListDataSetResponse {
  var runtime = new Util.RuntimeOptions{};
  var headers : map[string]string = {};
  return listDataSetWithOptions(headers, runtime);
}

model ListDataSet2Request {
  clientId?: long(name='clientId'),
  pageNo?: int32(name='pageNo'),
  pageSize?: int32(name='pageSize'),
}

model ListDataSet2ResponseBody = {
  code?: string(name='Code'),
  data?: {
    data?: [ 
      {
        createTime?: string(name='createTime'),
        datasetId?: long(name='datasetId'),
        lineNum?: long(name='lineNum'),
        name?: string(name='name'),
        status?: string(name='status'),
        type?: string(name='type'),
      }
    ](name='data'),
    totalNum?: int32(name='totalNum'),
  }(name='Data'),
  msg?: string(name='Msg'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model ListDataSet2Response = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: ListDataSet2ResponseBody(name='body'),
}

/**
 * @summary 查询单个数据集
 *
 * @param request ListDataSet2Request
 * @param headers map
 * @param runtime runtime options for this request RuntimeOptions
 * @return ListDataSet2Response
 */
async function listDataSet2WithOptions(request: ListDataSet2Request, headers: map[string]string, runtime: Util.RuntimeOptions): ListDataSet2Response {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.clientId)) {
    body['clientId'] = request.clientId;
  }
  if (!Util.isUnset(request.pageNo)) {
    body['pageNo'] = request.pageNo;
  }
  if (!Util.isUnset(request.pageSize)) {
    body['pageSize'] = request.pageSize;
  }

  var req = new OpenApi.OpenApiRequest{ 
    headers = headers,
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'ListDataSet2',
    version = '2022-09-13',
    protocol = 'HTTPS',
    pathname = `/bc/listDataSet2`,
    method = 'POST',
    authType = 'AK',
    style = 'ROA',
    reqBodyType = 'json',
    bodyType = 'json',
  };
  if (Util.isUnset(@signatureVersion) || !Util.equalString(@signatureVersion, 'v4')) {
    return callApi(params, req, runtime);
  } else {
    return execute(params, req, runtime);
  }
}

/**
 * @summary 查询单个数据集
 *
 * @param request ListDataSet2Request
 * @return ListDataSet2Response
 */
async function listDataSet2(request: ListDataSet2Request): ListDataSet2Response {
  var runtime = new Util.RuntimeOptions{};
  var headers : map[string]string = {};
  return listDataSet2WithOptions(request, headers, runtime);
}

model RemoveDataSetRequest {
  body?: long(name='body'),
}

model RemoveDataSetResponseBody = {
  code?: string(name='Code'),
  data?: boolean(name='Data'),
  msg?: string(name='Msg'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model RemoveDataSetResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: RemoveDataSetResponseBody(name='body'),
}

/**
 * @summary 删除数据集
 *
 * @param request RemoveDataSetRequest
 * @param headers map
 * @param runtime runtime options for this request RuntimeOptions
 * @return RemoveDataSetResponse
 */
async function removeDataSetWithOptions(request: RemoveDataSetRequest, headers: map[string]string, runtime: Util.RuntimeOptions): RemoveDataSetResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    headers = headers,
    body = request.body,
  };
  var params = new OpenApi.Params{
    action = 'RemoveDataSet',
    version = '2022-09-13',
    protocol = 'HTTPS',
    pathname = `/bc/removeDataSet`,
    method = 'POST',
    authType = 'AK',
    style = 'ROA',
    reqBodyType = 'json',
    bodyType = 'json',
  };
  if (Util.isUnset(@signatureVersion) || !Util.equalString(@signatureVersion, 'v4')) {
    return callApi(params, req, runtime);
  } else {
    return execute(params, req, runtime);
  }
}

/**
 * @summary 删除数据集
 *
 * @param request RemoveDataSetRequest
 * @return RemoveDataSetResponse
 */
async function removeDataSet(request: RemoveDataSetRequest): RemoveDataSetResponse {
  var runtime = new Util.RuntimeOptions{};
  var headers : map[string]string = {};
  return removeDataSetWithOptions(request, headers, runtime);
}

model RemoveDataSet2Request {
  clientId?: long(name='clientId'),
  dataSetId?: long(name='dataSetId'),
}

model RemoveDataSet2ResponseBody = {
  code?: string(name='Code'),
  data?: boolean(name='Data'),
  msg?: string(name='Msg'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model RemoveDataSet2Response = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: RemoveDataSet2ResponseBody(name='body'),
}

/**
 * @summary 删除数据集
 *
 * @param request RemoveDataSet2Request
 * @param headers map
 * @param runtime runtime options for this request RuntimeOptions
 * @return RemoveDataSet2Response
 */
async function removeDataSet2WithOptions(request: RemoveDataSet2Request, headers: map[string]string, runtime: Util.RuntimeOptions): RemoveDataSet2Response {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.clientId)) {
    body['clientId'] = request.clientId;
  }
  if (!Util.isUnset(request.dataSetId)) {
    body['dataSetId'] = request.dataSetId;
  }

  var req = new OpenApi.OpenApiRequest{ 
    headers = headers,
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'RemoveDataSet2',
    version = '2022-09-13',
    protocol = 'HTTPS',
    pathname = `/bc/removeDataSet2`,
    method = 'POST',
    authType = 'AK',
    style = 'ROA',
    reqBodyType = 'json',
    bodyType = 'json',
  };
  if (Util.isUnset(@signatureVersion) || !Util.equalString(@signatureVersion, 'v4')) {
    return callApi(params, req, runtime);
  } else {
    return execute(params, req, runtime);
  }
}

/**
 * @summary 删除数据集
 *
 * @param request RemoveDataSet2Request
 * @return RemoveDataSet2Response
 */
async function removeDataSet2(request: RemoveDataSet2Request): RemoveDataSet2Response {
  var runtime = new Util.RuntimeOptions{};
  var headers : map[string]string = {};
  return removeDataSet2WithOptions(request, headers, runtime);
}

model SelectComputeTaskRequest {
  body?: long(name='body'),
}

model SelectComputeTaskResponseBody = {
  code?: string(name='Code'),
  data?: {
    appId?: long(name='appId'),
    bcId?: long(name='bcId'),
    computeOssFileTitle?: string(name='computeOssFileTitle'),
    datasetIds?: string(name='datasetIds'),
    exportOssFileList?: [ 
      {
        downLoadUrl?: string(name='downLoadUrl'),
        password?: string(name='password'),
      }
    ](name='exportOssFileList'),
    extInfo?: string(name='extInfo'),
    fileNum?: long(name='fileNum'),
    name?: string(name='name'),
    remarks?: string(name='remarks'),
    status?: string(name='status'),
    taskResultList?: [ 
      {
        bcId?: long(name='bcId'),
        code?: int32(name='code'),
        lineNum?: long(name='lineNum'),
      }
    ](name='taskResultList'),
  }(name='Data'),
  msg?: string(name='Msg'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model SelectComputeTaskResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: SelectComputeTaskResponseBody(name='body'),
}

/**
 * @summary 查询单个批量任务
 *
 * @param request SelectComputeTaskRequest
 * @param headers map
 * @param runtime runtime options for this request RuntimeOptions
 * @return SelectComputeTaskResponse
 */
async function selectComputeTaskWithOptions(request: SelectComputeTaskRequest, headers: map[string]string, runtime: Util.RuntimeOptions): SelectComputeTaskResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    headers = headers,
    body = request.body,
  };
  var params = new OpenApi.Params{
    action = 'SelectComputeTask',
    version = '2022-09-13',
    protocol = 'HTTPS',
    pathname = `/bc/selectComputeTask`,
    method = 'POST',
    authType = 'AK',
    style = 'ROA',
    reqBodyType = 'json',
    bodyType = 'json',
  };
  if (Util.isUnset(@signatureVersion) || !Util.equalString(@signatureVersion, 'v4')) {
    return callApi(params, req, runtime);
  } else {
    return execute(params, req, runtime);
  }
}

/**
 * @summary 查询单个批量任务
 *
 * @param request SelectComputeTaskRequest
 * @return SelectComputeTaskResponse
 */
async function selectComputeTask(request: SelectComputeTaskRequest): SelectComputeTaskResponse {
  var runtime = new Util.RuntimeOptions{};
  var headers : map[string]string = {};
  return selectComputeTaskWithOptions(request, headers, runtime);
}

model SelectComputeTask2Request {
  bcConfirm?: boolean(name='bcConfirm'),
  bcId?: long(name='bcId'),
  clientId?: long(name='clientId'),
}

model SelectComputeTask2ResponseBody = {
  code?: string(name='Code'),
  data?: {
    appId?: long(name='appId'),
    bcId?: long(name='bcId'),
    computeOssFileTitle?: string(name='computeOssFileTitle'),
    datasetIds?: string(name='datasetIds'),
    exportOssFileList?: [ 
      {
        downLoadUrl?: string(name='downLoadUrl'),
        password?: string(name='password'),
      }
    ](name='exportOssFileList'),
    extInfo?: string(name='extInfo'),
    fileNum?: long(name='fileNum'),
    hint?: string(name='hint'),
    name?: string(name='name'),
    remarks?: string(name='remarks'),
    status?: string(name='status'),
    taskResultList?: [ 
      {
        bcId?: long(name='bcId'),
        code?: int32(name='code'),
        lineNum?: long(name='lineNum'),
      }
    ](name='taskResultList'),
  }(name='Data'),
  msg?: string(name='Msg'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model SelectComputeTask2Response = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: SelectComputeTask2ResponseBody(name='body'),
}

/**
 * @summary 查询单个批量任务
 *
 * @param request SelectComputeTask2Request
 * @param headers map
 * @param runtime runtime options for this request RuntimeOptions
 * @return SelectComputeTask2Response
 */
async function selectComputeTask2WithOptions(request: SelectComputeTask2Request, headers: map[string]string, runtime: Util.RuntimeOptions): SelectComputeTask2Response {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.bcConfirm)) {
    body['bcConfirm'] = request.bcConfirm;
  }
  if (!Util.isUnset(request.bcId)) {
    body['bcId'] = request.bcId;
  }
  if (!Util.isUnset(request.clientId)) {
    body['clientId'] = request.clientId;
  }

  var req = new OpenApi.OpenApiRequest{ 
    headers = headers,
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'SelectComputeTask2',
    version = '2022-09-13',
    protocol = 'HTTPS',
    pathname = `/bc/selectComputeTask2`,
    method = 'POST',
    authType = 'AK',
    style = 'ROA',
    reqBodyType = 'json',
    bodyType = 'json',
  };
  if (Util.isUnset(@signatureVersion) || !Util.equalString(@signatureVersion, 'v4')) {
    return callApi(params, req, runtime);
  } else {
    return execute(params, req, runtime);
  }
}

/**
 * @summary 查询单个批量任务
 *
 * @param request SelectComputeTask2Request
 * @return SelectComputeTask2Response
 */
async function selectComputeTask2(request: SelectComputeTask2Request): SelectComputeTask2Response {
  var runtime = new Util.RuntimeOptions{};
  var headers : map[string]string = {};
  return selectComputeTask2WithOptions(request, headers, runtime);
}

model SelectDataSetRequest {
  body?: long(name='body'),
}

model SelectDataSetResponseBody = {
  code?: string(name='Code'),
  data?: {
    createTime?: string(name='createTime'),
    datasetId?: long(name='datasetId'),
    lineNum?: long(name='lineNum'),
    name?: string(name='name'),
    status?: string(name='status'),
    type?: string(name='type'),
  }(name='Data'),
  msg?: string(name='Msg'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model SelectDataSetResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: SelectDataSetResponseBody(name='body'),
}

/**
 * @summary 查询单个数据集
 *
 * @param request SelectDataSetRequest
 * @param headers map
 * @param runtime runtime options for this request RuntimeOptions
 * @return SelectDataSetResponse
 */
async function selectDataSetWithOptions(request: SelectDataSetRequest, headers: map[string]string, runtime: Util.RuntimeOptions): SelectDataSetResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    headers = headers,
    body = request.body,
  };
  var params = new OpenApi.Params{
    action = 'SelectDataSet',
    version = '2022-09-13',
    protocol = 'HTTPS',
    pathname = `/bc/selectDataSet`,
    method = 'POST',
    authType = 'AK',
    style = 'ROA',
    reqBodyType = 'json',
    bodyType = 'json',
  };
  if (Util.isUnset(@signatureVersion) || !Util.equalString(@signatureVersion, 'v4')) {
    return callApi(params, req, runtime);
  } else {
    return execute(params, req, runtime);
  }
}

/**
 * @summary 查询单个数据集
 *
 * @param request SelectDataSetRequest
 * @return SelectDataSetResponse
 */
async function selectDataSet(request: SelectDataSetRequest): SelectDataSetResponse {
  var runtime = new Util.RuntimeOptions{};
  var headers : map[string]string = {};
  return selectDataSetWithOptions(request, headers, runtime);
}

model SelectDataSet2Request {
  clientId?: long(name='clientId'),
  dataSetId?: long(name='dataSetId'),
}

model SelectDataSet2ResponseBody = {
  code?: string(name='Code'),
  data?: {
    createTime?: string(name='createTime'),
    datasetId?: long(name='datasetId'),
    lineNum?: long(name='lineNum'),
    name?: string(name='name'),
    ossFileCount?: long(name='ossFileCount'),
    status?: string(name='status'),
    statusMsg?: string(name='statusMsg'),
    type?: string(name='type'),
  }(name='Data'),
  msg?: string(name='Msg'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model SelectDataSet2Response = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: SelectDataSet2ResponseBody(name='body'),
}

/**
 * @summary 查询单个数据集
 *
 * @param request SelectDataSet2Request
 * @param headers map
 * @param runtime runtime options for this request RuntimeOptions
 * @return SelectDataSet2Response
 */
async function selectDataSet2WithOptions(request: SelectDataSet2Request, headers: map[string]string, runtime: Util.RuntimeOptions): SelectDataSet2Response {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.clientId)) {
    body['clientId'] = request.clientId;
  }
  if (!Util.isUnset(request.dataSetId)) {
    body['dataSetId'] = request.dataSetId;
  }

  var req = new OpenApi.OpenApiRequest{ 
    headers = headers,
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'SelectDataSet2',
    version = '2022-09-13',
    protocol = 'HTTPS',
    pathname = `/bc/selectDataSet2`,
    method = 'POST',
    authType = 'AK',
    style = 'ROA',
    reqBodyType = 'json',
    bodyType = 'json',
  };
  if (Util.isUnset(@signatureVersion) || !Util.equalString(@signatureVersion, 'v4')) {
    return callApi(params, req, runtime);
  } else {
    return execute(params, req, runtime);
  }
}

/**
 * @summary 查询单个数据集
 *
 * @param request SelectDataSet2Request
 * @return SelectDataSet2Response
 */
async function selectDataSet2(request: SelectDataSet2Request): SelectDataSet2Response {
  var runtime = new Util.RuntimeOptions{};
  var headers : map[string]string = {};
  return selectDataSet2WithOptions(request, headers, runtime);
}

model SubmitDataSetTaskRequest {
  body?: long(name='body'),
}

model SubmitDataSetTaskResponseBody = {
  code?: string(name='Code'),
  data?: boolean(name='Data'),
  msg?: string(name='Msg'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model SubmitDataSetTaskResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: SubmitDataSetTaskResponseBody(name='body'),
}

/**
 * @summary 提交数据集任务，校验数据集
 *
 * @param request SubmitDataSetTaskRequest
 * @param headers map
 * @param runtime runtime options for this request RuntimeOptions
 * @return SubmitDataSetTaskResponse
 */
async function submitDataSetTaskWithOptions(request: SubmitDataSetTaskRequest, headers: map[string]string, runtime: Util.RuntimeOptions): SubmitDataSetTaskResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    headers = headers,
    body = request.body,
  };
  var params = new OpenApi.Params{
    action = 'SubmitDataSetTask',
    version = '2022-09-13',
    protocol = 'HTTPS',
    pathname = `/bc/submitDataSetTask`,
    method = 'POST',
    authType = 'AK',
    style = 'ROA',
    reqBodyType = 'json',
    bodyType = 'json',
  };
  if (Util.isUnset(@signatureVersion) || !Util.equalString(@signatureVersion, 'v4')) {
    return callApi(params, req, runtime);
  } else {
    return execute(params, req, runtime);
  }
}

/**
 * @summary 提交数据集任务，校验数据集
 *
 * @param request SubmitDataSetTaskRequest
 * @return SubmitDataSetTaskResponse
 */
async function submitDataSetTask(request: SubmitDataSetTaskRequest): SubmitDataSetTaskResponse {
  var runtime = new Util.RuntimeOptions{};
  var headers : map[string]string = {};
  return submitDataSetTaskWithOptions(request, headers, runtime);
}

model SubmitDataSetTask2Request {
  clientId?: long(name='clientId'),
  dataSetId?: long(name='dataSetId'),
}

model SubmitDataSetTask2ResponseBody = {
  code?: string(name='Code'),
  data?: boolean(name='Data'),
  msg?: string(name='Msg'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model SubmitDataSetTask2Response = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: SubmitDataSetTask2ResponseBody(name='body'),
}

/**
 * @summary 提交数据集任务，校验数据集
 *
 * @param request SubmitDataSetTask2Request
 * @param headers map
 * @param runtime runtime options for this request RuntimeOptions
 * @return SubmitDataSetTask2Response
 */
async function submitDataSetTask2WithOptions(request: SubmitDataSetTask2Request, headers: map[string]string, runtime: Util.RuntimeOptions): SubmitDataSetTask2Response {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.clientId)) {
    body['clientId'] = request.clientId;
  }
  if (!Util.isUnset(request.dataSetId)) {
    body['dataSetId'] = request.dataSetId;
  }

  var req = new OpenApi.OpenApiRequest{ 
    headers = headers,
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'SubmitDataSetTask2',
    version = '2022-09-13',
    protocol = 'HTTPS',
    pathname = `/bc/submitDataSetTask2`,
    method = 'POST',
    authType = 'AK',
    style = 'ROA',
    reqBodyType = 'json',
    bodyType = 'json',
  };
  if (Util.isUnset(@signatureVersion) || !Util.equalString(@signatureVersion, 'v4')) {
    return callApi(params, req, runtime);
  } else {
    return execute(params, req, runtime);
  }
}

/**
 * @summary 提交数据集任务，校验数据集
 *
 * @param request SubmitDataSetTask2Request
 * @return SubmitDataSetTask2Response
 */
async function submitDataSetTask2(request: SubmitDataSetTask2Request): SubmitDataSetTask2Response {
  var runtime = new Util.RuntimeOptions{};
  var headers : map[string]string = {};
  return submitDataSetTask2WithOptions(request, headers, runtime);
}

